JavaScript Temporal Durationin hallinta: Kattava opas aikavälien laskentaan

JavaScriptin Temporal API on merkittävä edistysaskel päivämäärien ja aikojen käsittelyssä. Yksi sen ydin-komponenteista on Duration-olio, joka on suunniteltu erityisesti aikavälien esittämiseen. Toisin kuin perinteinen Date-olio, joka kärsii muuttuvuudesta ja aikavyöhykekompleksisuudesta, Duration tarjoaa selkeämmän, tarkemman ja kansainvälisesti tiedostavan tavan työskennellä aikajaksojen kanssa. Tämä kattava opas tutkii Duration-oliota yksityiskohtaisesti, kattaen kaiken peruskäytöstä edistyneisiin skenaarioihin.

Mikä on Temporal Duration?

Temporal.Duration edustaa aikajaksoa, joka on riippumaton mistään tietystä kalenterijärjestelmästä tai aikavyöhykkeestä. Se keskittyy ainoastaan ajan määrään, joka ilmaistaan vuosina, kuukausina, päivinä, tunteina, minuutteina, sekunteina ja sekunnin murto-osina. Ajattele sitä muodossa "5 vuotta, 3 kuukautta ja 2 päivää" sen sijaan, että se olisi "1. tammikuuta 2023 - 3. maaliskuuta 2028".

Tämä ero on ratkaiseva, koska kestot ovat luonnostaan suhteellisia. Keston lisääminen tiettyyn päivämäärään johtaa aina uuteen päivämäärään, mutta tarkka tulos riippuu kalenterijärjestelmästä ja lähtöpäivämäärästä. Esimerkiksi yhden kuukauden lisääminen tammikuun 31. päivään tuottaa eri päivämäärän riippuen siitä, onko kyseessä karkausvuosi.

Duration-olioiden luominen

On olemassa useita tapoja luoda Temporal.Duration-olioita:

1. Komponenteista

Suorin tapa on käyttää Temporal.Duration.from-metodia objektilla, joka sisältää halutut komponentit:

            const duration1 = Temporal.Duration.from({ years: 1, months: 6, days: 15 });
console.log(duration1.toString()); // Output: P1Y6M15D

const duration2 = Temporal.Duration.from({ hours: 8, minutes: 30, seconds: 12, milliseconds: 500 });
console.log(duration2.toString()); // Output: PT8H30M12.5S

const duration3 = Temporal.Duration.from({ years: 2, days: -5, seconds: 30 });
console.log(duration3.toString()); // Output: P2YT-5S30S

            

              
                Copy
              
            
          

Huomaa, että voit käyttää negatiivisia arvoja esittämään kestoja, jotka liikkuvat ajassa taaksepäin.

2. ISO 8601 -merkkijonosta

Temporal.Duration.from-metodi hyväksyy myös ISO 8601 -kestomerkkijonon:

            const duration4 = Temporal.Duration.from('P3Y2M10DT5H30M');
console.log(duration4.toString()); // Output: P3Y2M10DT5H30M

const duration5 = Temporal.Duration.from('PT1H15M30S');
console.log(duration5.toString()); // Output: PT1H15M30S

const duration6 = Temporal.Duration.from('P-1Y');
console.log(duration6.toString()); // Output: P-1Y

            

              
                Copy
              
            
          

ISO 8601 -kestomuoto on P[vuodet]Y[kuukaudet]M[päivät]D[T[tunnit]H[minuutit]M[sekunnit]S]. 'P' tarkoittaa jaksoa (period, duration), ja 'T' erottaa päivämäärä- ja aikakomponentit.

3. Konstruktorin käyttö

Voit myös käyttää Temporal.Duration-konstruktoria suoraan:

            const duration7 = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8);
console.log(duration7.toString()); // Output: P1Y2M3W4DT5H6M7S8ms

            

              
                Copy
              
            
          

Konstruktorin argumentit ovat järjestyksessä: years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds.

Durationin ominaisuudet

Kun sinulla on Duration-olio, voit käyttää sen komponentteja sen ominaisuuksien kautta:

            const duration = Temporal.Duration.from('P1Y2M3DT4H5M6S');

console.log(duration.years);       // Output: 1
console.log(duration.months);      // Output: 2
console.log(duration.days);        // Output: 3
console.log(duration.hours);       // Output: 4
console.log(duration.minutes);     // Output: 5
console.log(duration.seconds);     // Output: 6
console.log(duration.milliseconds);  // Output: 0
console.log(duration.microseconds);  // Output: 0
console.log(duration.nanoseconds);   // Output: 0

            

              
                Copy
              
            
          

Durationin aritmetiikka

Duration-olio tarjoaa metodeja aritmeettisten operaatioiden suorittamiseen:

1. Kestojen lisääminen

Käytä add-metodia kahden keston yhteenlaskemiseen:

            const duration1 = Temporal.Duration.from('P1Y2M');
const duration2 = Temporal.Duration.from('P3M4D');

const sum = duration1.add(duration2);
console.log(sum.toString()); // Output: P1Y5M4D

            

              
                Copy
              
            
          

2. Kestojen vähentäminen

Käytä subtract-metodia vähentääksesi yhden keston toisesta:

            const duration1 = Temporal.Duration.from('P1Y2M');
const duration2 = Temporal.Duration.from('P3M4D');

const difference = duration1.subtract(duration2);
console.log(difference.toString()); // Output: PPT11M-4D

            

              
                Copy
              
            
          

3. Keston negaatio

Käytä negated-metodia kääntääksesi kaikkien komponenttien etumerkin kestossa:

            const duration = Temporal.Duration.from('P1Y2M-3D');
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Output: P-1YT-2M3D

            

              
                Copy
              
            
          

4. Keston itseisarvo

Käytä abs-metodia saadaksesi keston, jossa kaikki komponentit ovat positiivisia:

            const duration = Temporal.Duration.from('P-1YT2M-3D');
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Output: P1YT2M3D

            

              
                Copy
              
            
          

5. Keston kertominen

Käytä multiply-metodia kertoaksesi keston luvulla:

            const duration = Temporal.Duration.from('PT1H30M');
const multipliedDuration = duration.multiply(2.5);
console.log(multipliedDuration.toString()); // Output: PT3H45M

            

              
                Copy
              
            
          

6. Keston pyöristäminen

Käytä round-metodia pyöristääksesi keston tiettyyn yksikköön. Tämä vaatii relativeTo-option antamista, joka voi olla Temporal.PlainDateTime tai Temporal.ZonedDateTime, koska joidenkin yksiköiden (kuten kuukausien ja vuosien) pituudet vaihtelevat.

            const duration = Temporal.Duration.from('P1DT12H30M');
const relativeTo = Temporal.PlainDateTime.from('2024-01-01T00:00:00');

const roundedDuration = duration.round({ smallestUnit: 'days', relativeTo });
console.log(roundedDuration.toString()); // Output: P2D

            

              
                Copy
              
            
          

Tässä esimerkissä 1 päivä ja 12 tuntia pyöristetään 2 päiväksi.

Kestojen vertailu

Voit verrata kahta kestoa käyttämällä compare-metodia. Pidä kuitenkin mielessä, että kestoja, joissa on sekoitettuja yksiköitä (esim. vuosia ja päiviä), ei voi luotettavasti verrata ilman suhteellista kontekstia (tiettyä päivämäärää ja kalenteria). compare-funktio palauttaa:

• -1, jos duration1 on pienempi kuin duration2
• 0, jos duration1 on yhtä suuri kuin duration2
• 1, jos duration1 on suurempi kuin duration2

            const duration1 = Temporal.Duration.from('PT1H');
const duration2 = Temporal.Duration.from('PT30M');

console.log(Temporal.Duration.compare(duration1, duration2)); // Output: 1
console.log(Temporal.Duration.compare(duration2, duration1)); // Output: -1
console.log(Temporal.Duration.compare(duration1, Temporal.Duration.from('PT1H'))); // Output: 0

const duration3 = Temporal.Duration.from('P1M');
const duration4 = Temporal.Duration.from('P30D');

// duration3:n ja duration4:n suora vertailu heittää virheen monissa moottoreissa
// ellei 'relativeTo'-optiota ole määritelty, koska kuukauden pituus ei ole vakio.

            

              
                Copy
              
            
          

Käytännön esimerkkejä ja käyttötapauksia

Temporal.Duration-olio on uskomattoman monipuolinen ja sitä voidaan käyttää monenlaisissa sovelluksissa:

1. Projektin keston laskeminen

Kuvittele, että hallinnoit projektia, jolla on alkamis- ja päättymispäivämäärä. Voit käyttää Temporal.PlainDate- ja Temporal.Duration-olioita projektin keston laskemiseen:

            const startDate = Temporal.PlainDate.from('2024-01-15');
const endDate = Temporal.PlainDate.from('2024-03-20');

const duration = endDate.since(startDate);
console.log(duration.toString()); // Output: P1M5D

            

              
                Copy
              
            
          

2. Toistuvien tapahtumien aikatauluttaminen

Voit käyttää Temporal.Duration-oliota määrittämään toistuvien tapahtumien, kuten viikoittaisten kokousten tai kuukausittaisten raporttien, tiheyden:

            const eventFrequency = Temporal.Duration.from({ weeks: 1 });
let nextEventDate = Temporal.PlainDate.from('2024-01-22');

for (let i = 0; i < 5; i++) {
  console.log(`Event ${i + 1}: ${nextEventDate.toString()}`);
  nextEventDate = nextEventDate.add(eventFrequency);
}

// Output:
// Event 1: 2024-01-22
// Event 2: 2024-01-29
// Event 3: 2024-02-05
// Event 4: 2024-02-12
// Event 5: 2024-02-19

            

              
                Copy
              
            
          

3. Iän laskeminen

Vaikka iän tarkka laskeminen vaatii karkausvuosien ja eri kalenterijärjestelmien käsittelyä, Temporal.Duration voi antaa hyvän likiarvon:

            const birthDate = Temporal.PlainDate.from('1990-05-10');
const today = Temporal.PlainDate.from('2024-02-15');

const ageDuration = today.since(birthDate);

console.log(`Likiarvoinen ikä: ${ageDuration.years} vuotta, ${ageDuration.months} kuukautta, ${ageDuration.days} päivää`);

            

              
                Copy
              
            
          

4. Aikavyöhyketietoiset laskelmat: Lentojen kestot

Globaaleissa sovelluksissa aikavyöhykkeiden käsittely on kriittistä. Harkitse lentojen kestojen laskemista eri aikavyöhykkeiden välillä:

            const departureZonedDateTime = Temporal.ZonedDateTime.from('2024-03-15T10:00:00[America/Los_Angeles]');
const arrivalZonedDateTime = Temporal.ZonedDateTime.from('2024-03-16T14:30:00[Europe/London]');

const flightDuration = arrivalZonedDateTime.since(departureZonedDateTime);

console.log(`Lennon kesto: ${flightDuration.hours} tuntia, ${flightDuration.minutes} minuuttia`);
console.log(flightDuration.toString());

            

              
                Copy
              
            
          

Tämä esimerkki osoittaa, kuinka Temporal.ZonedDateTime, yhdistettynä .since()-metodiin, säätää automaattisesti aikavyöhyke-erot ja antaa tarkan lennon keston.

5. Palvelutasosopimusten (SLA) seuranta

Monet verkkopalvelut lupaavat käytettävyystakuita. Voit käyttää `Temporal.Duration`-oliota näiden sopimusten määrittämiseen ja seuraamiseen.

            const slaGuarantee = Temporal.Duration.from('PT99H59M59S'); // Lähes 100 tuntia
const downtime = Temporal.Duration.from('PT1H');

if (downtime.compare(slaGuarantee) > 0) {
  console.log("SLA-sopimusta rikottu!");
} else {
  console.log("SLA täytetty.");
}

            

              
                Copy
              
            
          

Edistyneitä huomioita

1. Kuukausien ja vuosien epäselvyys

Kuten aiemmin mainittiin, kuukausien ja vuosien pituudet voivat vaihdella. Kun suoritetaan laskelmia, jotka sisältävät näitä yksiköitä, on usein tarpeen antaa suhteellinen konteksti käyttämällä Temporal.PlainDateTime- tai Temporal.ZonedDateTime-oliota. Tämä on erityisen tärkeää kestoja pyöristettäessä tai verrattaessa.

2. Kalenterijärjestelmät

Temporal API tukee eri kalenterijärjestelmiä. Oletuksena se käyttää ISO 8601 -kalenteria, joka on laajimmin käytetty. Voit kuitenkin määrittää muita kalenterijärjestelmiä luodessasi Temporal.PlainDate- tai Temporal.ZonedDateTime-olioita. Kestot pysyvät kalenterista riippumattomina; ne edustavat ajan määrää.

3. Aikavyöhyketietokannan päivitykset

Aikavyöhykesäännöt voivat muuttua ajan myötä poliittisista tai maantieteellisistä syistä. On ratkaisevan tärkeää pitää aikavyöhyketietokanta ajan tasalla tarkkojen laskelmien varmistamiseksi, erityisesti käsiteltäessä Temporal.ZonedDateTime-oliota. Nykyaikaiset JavaScript-ajoympäristöt hoitavat tämän tyypillisesti automaattisesti, mutta joissakin ympäristöissä saatat joutua päivittämään tietokannan manuaalisesti.

Parhaat käytännöt

• Käytä ISO 8601 -kestomerkkijonoja sarjallistamiseen ja tiedonvaihtoon. Tämä varmistaa yhteensopivuuden ja välttää epäselvyyksiä.
• Suosi Temporal.Duration-oliota aikavälien esittämiseen sen sijaan, että lasket erotuksen kahden Date-olion välillä suoraan. Tämä johtaa selkeämpään ja ylläpidettävämpään koodiin.
• Ole tietoinen kuukausien ja vuosien epäselvyydestä ja anna aina suhteellinen konteksti tarvittaessa.
• Käytä Temporal.ZonedDateTime-oliota aikavyöhyketietoisiin laskelmiin.
• Pidä aikavyöhyketietokantasi ajan tasalla.
• Kun vertailet kestoja, joissa on sekoitettuja yksiköitä, käytä aina round-metodia suhteellisella kontekstilla varmistaaksesi tarkan vertailun.

Yhteenveto

Temporal.Duration-olio tarjoaa tehokkaan ja intuitiivisen tavan työskennellä aikavälien kanssa JavaScriptissä. Ymmärtämällä sen ominaisuudet, metodit ja parhaat käytännöt voit kirjoittaa vankempaa, tarkempaa ja kansainvälisesti tiedostavampaa koodia. Temporal API, ja erityisesti Duration-olio, edustavat merkittävää edistysaskelta JavaScriptin päivämäärä- ja aikakäsittelyssä, mikä helpottaa sekä tarkkojen että globaalisti relevanttien sovellusten rakentamista. Ota Temporal API käyttöön ja hyödynnä sen potentiaali yksinkertaistaaksesi aikaan liittyviä laskelmiasi.

Temporal API:n kehittyessä pysy ajan tasalla uusista ominaisuuksista ja päivityksistä. Virallinen ECMAScript-ehdotus ja siihen liittyvä dokumentaatio ovat erinomaisia resursseja ajan tasalla pysymiseen.